'Weak Dependency Graph [60.0]'
------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, t(r(u(x1))) -> t(c(r(x1)))
, t(s(u(x1))) -> t(c(r(x1)))
, t(n(u(x1))) -> t(c(r(x1)))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)}
Details:
We have computed the following set of weak (innermost) dependency pairs:
{ r^#(r(x1)) -> c_0(s^#(r(x1)))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, r^#(b(x1)) -> c_3(s^#(b(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, n^#(u(x1)) -> c_6(n^#(x1))
, t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))
, t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))
, t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, c^#(n(x1)) -> c_14(n^#(x1))}
The usable rules are:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
The estimated dependency graph contains the following edges:
{r^#(r(x1)) -> c_0(s^#(r(x1)))}
==> {s^#(u(x1)) -> c_5(s^#(x1))}
{r^#(s(x1)) -> c_1(s^#(r(x1)))}
==> {s^#(u(x1)) -> c_5(s^#(x1))}
{r^#(n(x1)) -> c_2(s^#(r(x1)))}
==> {s^#(u(x1)) -> c_5(s^#(x1))}
{r^#(u(x1)) -> c_4(r^#(x1))}
==> {r^#(u(x1)) -> c_4(r^#(x1))}
{r^#(u(x1)) -> c_4(r^#(x1))}
==> {r^#(b(x1)) -> c_3(s^#(b(x1)))}
{r^#(u(x1)) -> c_4(r^#(x1))}
==> {r^#(n(x1)) -> c_2(s^#(r(x1)))}
{r^#(u(x1)) -> c_4(r^#(x1))}
==> {r^#(s(x1)) -> c_1(s^#(r(x1)))}
{r^#(u(x1)) -> c_4(r^#(x1))}
==> {r^#(r(x1)) -> c_0(s^#(r(x1)))}
{s^#(u(x1)) -> c_5(s^#(x1))}
==> {s^#(u(x1)) -> c_5(s^#(x1))}
{n^#(u(x1)) -> c_6(n^#(x1))}
==> {n^#(u(x1)) -> c_6(n^#(x1))}
{t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))}
==> {t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))}
{t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))}
==> {t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
{t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))}
==> {t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))}
{t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
==> {t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))}
{t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
==> {t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
{t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
==> {t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))}
{t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))}
==> {t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))}
{t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))}
==> {t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
{t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))}
==> {t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))}
{c^#(u(x1)) -> c_10(c^#(x1))}
==> {c^#(n(x1)) -> c_14(n^#(x1))}
{c^#(u(x1)) -> c_10(c^#(x1))}
==> {c^#(n(x1)) -> c_13(n^#(c(x1)))}
{c^#(u(x1)) -> c_10(c^#(x1))}
==> {c^#(r(x1)) -> c_12(r^#(c(x1)))}
{c^#(u(x1)) -> c_10(c^#(x1))}
==> {c^#(s(x1)) -> c_11(s^#(c(x1)))}
{c^#(u(x1)) -> c_10(c^#(x1))}
==> {c^#(u(x1)) -> c_10(c^#(x1))}
{c^#(s(x1)) -> c_11(s^#(c(x1)))}
==> {s^#(u(x1)) -> c_5(s^#(x1))}
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
==> {r^#(u(x1)) -> c_4(r^#(x1))}
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
==> {r^#(n(x1)) -> c_2(s^#(r(x1)))}
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
==> {r^#(s(x1)) -> c_1(s^#(r(x1)))}
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
==> {r^#(r(x1)) -> c_0(s^#(r(x1)))}
{c^#(n(x1)) -> c_13(n^#(c(x1)))}
==> {n^#(u(x1)) -> c_6(n^#(x1))}
{c^#(n(x1)) -> c_14(n^#(x1))}
==> {n^#(u(x1)) -> c_6(n^#(x1))}
We consider the following path(s):
1) { c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, s^#(u(x1)) -> c_5(s^#(x1))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [4]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{ c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [5]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(n(x1)) -> c_2(s^#(r(x1)))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(n(x1)) -> c_2(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [2]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [3]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [9]
n(x1) = [1] x1 + [10]
b(x1) = [1] x1 + [7]
u(x1) = [1] x1 + [9]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [8]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [3]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [8]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [3]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(r(x1)) -> s(r(x1))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(r(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [4]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [7]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [11]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [12]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [6]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [2]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_4_0(8) -> 8
, c_5_0(10) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
2) { c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, s^#(u(x1)) -> c_5(s^#(x1))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [4]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{ c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [5]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(r(x1)) -> c_0(s^#(r(x1)))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(r(x1)) -> c_0(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [2]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [3]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [9]
n(x1) = [1] x1 + [10]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [9]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [8]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(r(x1)) -> s(r(x1))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(r(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [4]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [7]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [13]
c_0(x1) = [1] x1 + [13]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [6]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [2]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_4_0(8) -> 8
, c_5_0(10) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
3) { t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))
, t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))
, t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))
, t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))
, t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ c(n(x1)) -> n(x1)
, t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))
, t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))
, t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c(n(x1)) -> n(x1)
, t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))
, t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))
, t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [4]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c^#(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ c(n(x1)) -> n(x1)
, t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))
, t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))
, t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [11]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [11]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [1] x1 + [0]
c^#(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(r(x1)) -> s(r(x1))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, c(n(x1)) -> n(x1)
, t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))
, t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))
, t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(r(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [4]
s(x1) = [1] x1 + [3]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [1]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [1] x1 + [0]
c^#(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c(n(x1)) -> n(x1)
, t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))
, t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))
, t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c(n(x1)) -> n(x1)
, t^#(r(u(x1))) -> c_7(t^#(c(r(x1))))
, t^#(n(u(x1))) -> c_9(t^#(c(r(x1))))
, t^#(s(u(x1))) -> c_8(t^#(c(r(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, t^#_0(4) -> 18
, t^#_0(5) -> 18}
4) { c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, s^#(u(x1)) -> c_5(s^#(x1))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [1] x1 + [7]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [7]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{ c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(s(x1)) -> c_1(s^#(r(x1)))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(s(x1)) -> c_1(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ r^#(s(x1)) -> c_1(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [2]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [1] x1 + [5]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [15]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [5]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [1] x1 + [2]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [8]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_5_0(10) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
5) { c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, s^#(u(x1)) -> c_5(s^#(x1))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [4]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [5]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(n(x1)) -> c_2(s^#(r(x1)))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(n(x1)) -> c_2(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [2]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [3]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [11]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
and weakly orienting the rules
{ r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [8]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [8]
n(x1) = [1] x1 + [11]
b(x1) = [1] x1 + [1]
u(x1) = [1] x1 + [3]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [7]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [7]
c_10(x1) = [1] x1 + [2]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [3]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [4]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [4]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [5]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [6]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_5_0(10) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
6) { c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, s^#(u(x1)) -> c_5(s^#(x1))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [5]
s^#(x1) = [1] x1 + [4]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(r(x1)) -> c_0(s^#(r(x1)))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(r(x1)) -> c_0(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [2]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [3]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [11]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
and weakly orienting the rules
{ r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [8]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [8]
n(x1) = [1] x1 + [11]
b(x1) = [1] x1 + [1]
u(x1) = [1] x1 + [3]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [2]
c_0(x1) = [1] x1 + [0]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [7]
c_10(x1) = [1] x1 + [2]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [2]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [4]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_5_0(10) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
7) { c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, s^#(u(x1)) -> c_5(s^#(x1))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [6]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [14]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [4]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [1] x1 + [5]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [8]
c_10(x1) = [1] x1 + [4]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(s(x1)) -> c_1(s^#(r(x1)))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(s(x1)) -> c_1(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [2]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [3]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [5]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r^#(s(x1)) -> c_1(s^#(r(x1)))
, r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [4]
c_1(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(2) -> 2
, u_0(2) -> 2
, r^#_0(2) -> 1
, s^#_0(2) -> 1
, c_4_0(1) -> 1
, c_5_0(1) -> 1
, c^#_0(2) -> 1
, c_10_0(1) -> 1}
8) { c^#(u(x1)) -> c_10(c^#(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, s^#(u(x1)) -> c_5(s^#(x1))}
The usable rules for this path are the following:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, s^#(u(x1)) -> c_5(s^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(s(x1)) -> c_11(s^#(c(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(s(x1)) -> c_11(s^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [1] x1 + [2]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [7]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [4]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [2]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [2]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [3]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [2]
b(x1) = [1] x1 + [13]
u(x1) = [1] x1 + [2]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [10]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [10]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [13]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{s^#(u(x1)) -> c_5(s^#(x1))}
and weakly orienting the rules
{ c^#(u(x1)) -> c_10(c^#(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{s^#(u(x1)) -> c_5(s^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [4]
b(x1) = [1] x1 + [8]
u(x1) = [1] x1 + [1]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [15]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [15]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ s^#(u(x1)) -> c_5(s^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ s^#(u(x1)) -> c_5(s^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_5_0(10) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
9) { c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(r(x1)) -> c_0(s^#(r(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(r(x1)) -> c_0(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [3]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{ r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [8]
c_10(x1) = [1] x1 + [5]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [4]
b(x1) = [1] x1 + [8]
u(x1) = [1] x1 + [10]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [2]
c_0(x1) = [1] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [2]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [4]
c_0(x1) = [1] x1 + [2]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_4_0(8) -> 8
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
10)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, r^#(b(x1)) -> c_3(s^#(b(x1)))}
The usable rules for this path are the following:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(b(x1)) -> c_3(s^#(b(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ c(n(x1)) -> n(x1)
, r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c(n(x1)) -> n(x1)
, r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [4]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(b(x1)) -> c_3(s^#(b(x1)))}
and weakly orienting the rules
{ c(n(x1)) -> n(x1)
, r(n(x1)) -> s(r(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(b(x1)) -> c_3(s^#(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{ r^#(b(x1)) -> c_3(s^#(b(x1)))
, c(n(x1)) -> n(x1)
, r(n(x1)) -> s(r(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [9]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(b(x1)) -> c_3(s^#(b(x1)))
, c(n(x1)) -> n(x1)
, r(n(x1)) -> s(r(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [4]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [2]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [6]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [2]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(b(x1)) -> c_3(s^#(b(x1)))
, c(n(x1)) -> n(x1)
, r(n(x1)) -> s(r(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [5]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [5]
u(x1) = [1] x1 + [1]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [7]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [7]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(b(x1)) -> c_3(s^#(b(x1)))
, c(n(x1)) -> n(x1)
, r(n(x1)) -> s(r(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(b(x1)) -> c_3(s^#(b(x1)))
, c(n(x1)) -> n(x1)
, r(n(x1)) -> s(r(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_3_0(10) -> 8
, c_4_0(8) -> 8
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
11)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(n(x1)) -> c_2(s^#(r(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(n(x1)) -> c_2(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [3]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{ r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [8]
c_10(x1) = [1] x1 + [5]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [4]
b(x1) = [1] x1 + [8]
u(x1) = [1] x1 + [10]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [2]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [2]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [4]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_4_0(8) -> 8
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
12)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ c(n(x1)) -> n(x1)
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c(n(x1)) -> n(x1)
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [7]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ c(n(x1)) -> n(x1)
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [3]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [3]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{ r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c(n(x1)) -> n(x1)
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [5]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c(n(x1)) -> n(x1)
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [8]
n(x1) = [1] x1 + [12]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [9]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [3]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [8]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [10]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c(n(x1)) -> n(x1)
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [9]
b(x1) = [1] x1 + [2]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [10]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [7]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [11]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [2]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c(n(x1)) -> n(x1)
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c(n(x1)) -> n(x1)
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c_4_0(8) -> 8
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
13)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(n(x1)) -> c_2(s^#(r(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(n(x1)) -> c_2(s^#(r(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(n(x1)) -> c_2(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [2]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [7]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{ r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [4]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [10]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [2]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [14]
s(x1) = [1] x1 + [12]
n(x1) = [1] x1 + [14]
b(x1) = [1] x1 + [6]
u(x1) = [1] x1 + [8]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [8]
r^#(x1) = [1] x1 + [3]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [2]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [12]
s(x1) = [1] x1 + [8]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [12]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [4]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(n(x1)) -> c_2(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
14)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(r(x1)) -> c_0(s^#(r(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(r(x1)) -> c_0(s^#(r(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(r(x1)) -> c_0(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [2]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [7]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{ r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [4]
c_0(x1) = [1] x1 + [1]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [10]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [2]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [14]
s(x1) = [1] x1 + [12]
n(x1) = [1] x1 + [14]
b(x1) = [1] x1 + [6]
u(x1) = [1] x1 + [8]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [8]
r^#(x1) = [1] x1 + [3]
c_0(x1) = [1] x1 + [0]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [2]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [12]
s(x1) = [1] x1 + [8]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [12]
c_0(x1) = [1] x1 + [0]
s^#(x1) = [1] x1 + [4]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(r(x1)) -> c_0(s^#(r(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
15)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
The usable rules for this path are the following:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ c(n(x1)) -> n(x1)
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c(n(x1)) -> n(x1)
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [5]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r^#(s(x1)) -> c_1(s^#(r(x1)))}
and weakly orienting the rules
{ c(n(x1)) -> n(x1)
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r^#(s(x1)) -> c_1(s^#(r(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ r^#(s(x1)) -> c_1(s^#(r(x1)))
, c(n(x1)) -> n(x1)
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [10]
n(x1) = [1] x1 + [11]
b(x1) = [1] x1 + [1]
u(x1) = [1] x1 + [6]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [2]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [12]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(r(x1)) -> s(r(x1))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, c(n(x1)) -> n(x1)
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(r(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [4]
b(x1) = [1] x1 + [9]
u(x1) = [1] x1 + [2]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [6]
r^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [15]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, c(n(x1)) -> n(x1)
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [12]
s(x1) = [1] x1 + [10]
n(x1) = [1] x1 + [10]
b(x1) = [1] x1 + [3]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [2]
r^#(x1) = [1] x1 + [3]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [8]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [4]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, c(n(x1)) -> n(x1)
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ r(b(x1)) -> u(s(b(x1)))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(s(x1)) -> c_1(s^#(r(x1)))
, c(n(x1)) -> n(x1)
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
16)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(n(x1)) -> c_13(n^#(c(x1)))}
The usable rules for this path are the following:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(n(x1)) -> c_13(n^#(c(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(n(x1)) -> c_13(n^#(c(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(n(x1)) -> c_13(n^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ c^#(n(x1)) -> c_13(n^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [14]
s(x1) = [1] x1 + [9]
n(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [2]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [2]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [7]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [1]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
u(x1) = [1] x1 + [1]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [8]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [15]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [1]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, r(n(x1)) -> s(r(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, r(n(x1)) -> s(r(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, n^#_0(4) -> 16
, n^#_0(5) -> 16
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
17)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
The usable rules for this path are the following:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [7]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [8]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [15]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [5]
u(x1) = [1] x1 + [8]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [3]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, r(n(x1)) -> s(r(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, r(n(x1)) -> s(r(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
18)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))}
The usable rules for this path are the following:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, c^#(u(x1)) -> c_10(c^#(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(s(x1)) -> c_11(s^#(c(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(s(x1)) -> c_11(s^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{r(n(x1)) -> s(r(x1))}
and weakly orienting the rules
{ c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{r(n(x1)) -> s(r(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [5]
n(x1) = [1] x1 + [13]
b(x1) = [1] x1 + [2]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [2]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ r(n(x1)) -> s(r(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [8]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [1] x1 + [4]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [8]
u(x1) = [1] x1 + [1]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [15]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [7]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, r(r(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(n(x1)) -> s(r(x1))
, c^#(s(x1)) -> c_11(s^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, s^#_0(4) -> 10
, s^#_0(5) -> 10
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
19)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, n^#(u(x1)) -> c_6(n^#(x1))}
The usable rules for this path are the following:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, n^#(u(x1)) -> c_6(n^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(n(x1)) -> c_13(n^#(c(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(n(x1)) -> c_13(n^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ c^#(n(x1)) -> c_13(n^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [12]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [15]
b(x1) = [1] x1 + [2]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [8]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ c^#(u(x1)) -> c_10(c^#(x1))
, n^#(u(x1)) -> c_6(n^#(x1))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c^#(u(x1)) -> c_10(c^#(x1))
, n^#(u(x1)) -> c_6(n^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [1]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [7]
c_6(x1) = [1] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [7]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, n^#(u(x1)) -> c_6(n^#(x1))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, n^#(u(x1)) -> c_6(n^#(x1))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(n(x1)) -> c_13(n^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, n^#_0(4) -> 16
, n^#_0(5) -> 16
, c_6_0(16) -> 16
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
20)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, r^#(u(x1)) -> c_4(r^#(x1))}
The usable rules for this path are the following:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, c(n(x1)) -> n(x1)
, r(r(x1)) -> s(r(x1))
, r(s(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c^#(u(x1)) -> c_10(c^#(x1))
, r^#(u(x1)) -> c_4(r^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c(n(x1)) -> n(x1)}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c(n(x1)) -> n(x1)}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
and weakly orienting the rules
{c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(r(x1)) -> c_12(r^#(c(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [2]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
and weakly orienting the rules
{ c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [8]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [1]
r^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ c^#(u(x1)) -> c_10(c^#(x1))
, r^#(u(x1)) -> c_4(r^#(x1))}
and weakly orienting the rules
{ r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ c^#(u(x1)) -> c_10(c^#(x1))
, r^#(u(x1)) -> c_4(r^#(x1))}
Details:
Interpretation Functions:
r(x1) = [1] x1 + [9]
s(x1) = [1] x1 + [0]
n(x1) = [1] x1 + [8]
b(x1) = [1] x1 + [1]
u(x1) = [1] x1 + [8]
t(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
r^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [8]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ c(u(x1)) -> u(c(x1))
, c(s(x1)) -> s(c(x1))
, c(r(x1)) -> r(c(x1))
, c(n(x1)) -> n(c(x1))
, r(s(x1)) -> s(r(x1))
, r(u(x1)) -> u(r(x1))
, s(u(x1)) -> u(s(x1))
, n(u(x1)) -> u(n(x1))}
Weak Rules:
{ c^#(u(x1)) -> c_10(c^#(x1))
, r^#(u(x1)) -> c_4(r^#(x1))
, r(r(x1)) -> s(r(x1))
, r(n(x1)) -> s(r(x1))
, r(b(x1)) -> u(s(b(x1)))
, c^#(r(x1)) -> c_12(r^#(c(x1)))
, c(n(x1)) -> n(x1)}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ b_0(4) -> 4
, b_0(5) -> 4
, u_0(4) -> 5
, u_0(5) -> 5
, r^#_0(4) -> 8
, r^#_0(5) -> 8
, c_4_0(8) -> 8
, c^#_0(4) -> 22
, c^#_0(5) -> 22
, c_10_0(22) -> 22}
21)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(n(x1)) -> c_14(n^#(x1))
, n^#(u(x1)) -> c_6(n^#(x1))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
r(x1) = [0] x1 + [0]
s(x1) = [0] x1 + [0]
n(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {n^#(u(x1)) -> c_6(n^#(x1))}
Weak Rules:
{ c^#(n(x1)) -> c_14(n^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{n^#(u(x1)) -> c_6(n^#(x1))}
and weakly orienting the rules
{ c^#(n(x1)) -> c_14(n^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{n^#(u(x1)) -> c_6(n^#(x1))}
Details:
Interpretation Functions:
r(x1) = [0] x1 + [0]
s(x1) = [0] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [0] x1 + [0]
u(x1) = [1] x1 + [8]
t(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [1]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [3]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [1] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ n^#(u(x1)) -> c_6(n^#(x1))
, c^#(n(x1)) -> c_14(n^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
The given problem does not contain any strict rules
22)
{ c^#(u(x1)) -> c_10(c^#(x1))
, c^#(n(x1)) -> c_14(n^#(x1))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
r(x1) = [0] x1 + [0]
s(x1) = [0] x1 + [0]
n(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {c^#(n(x1)) -> c_14(n^#(x1))}
Weak Rules: {c^#(u(x1)) -> c_10(c^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{c^#(n(x1)) -> c_14(n^#(x1))}
and weakly orienting the rules
{c^#(u(x1)) -> c_10(c^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(n(x1)) -> c_14(n^#(x1))}
Details:
Interpretation Functions:
r(x1) = [0] x1 + [0]
s(x1) = [0] x1 + [0]
n(x1) = [1] x1 + [0]
b(x1) = [0] x1 + [0]
u(x1) = [1] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [1] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ c^#(n(x1)) -> c_14(n^#(x1))
, c^#(u(x1)) -> c_10(c^#(x1))}
Details:
The given problem does not contain any strict rules
23)
{c^#(u(x1)) -> c_10(c^#(x1))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
r(x1) = [0] x1 + [0]
s(x1) = [0] x1 + [0]
n(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
t(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {c^#(u(x1)) -> c_10(c^#(x1))}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{c^#(u(x1)) -> c_10(c^#(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{c^#(u(x1)) -> c_10(c^#(x1))}
Details:
Interpretation Functions:
r(x1) = [0] x1 + [0]
s(x1) = [0] x1 + [0]
n(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
u(x1) = [1] x1 + [8]
t(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
r^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
s^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
n^#(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
t^#(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c^#(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [3]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {c^#(u(x1)) -> c_10(c^#(x1))}
Details:
The given problem does not contain any strict rules